Python 元组

        元组是序列的一种。序列包括字符串、列表和元组。

序列说明

        序列的两个主要特点是索引操作符和切片操作符

  • 索引操作符让我们可以从序列中抓取一个特定项目
  • 切片操作符让我们能够获取序列的一个切片，即一部分序列。

        序列的基本操作

  • len()：求序列的长度
1
2
3
4
In [1]: a = 'abc'
In [2]: len(a)
Out[2]: 3
  • +：连接2个序列
1
2
In [3]: a + 'd'
Out[3]: 'abcd'
  • *：重复序列元素
1
2
3
4
5
6
7
8
In [4]: a
Out[4]: 'abc'
In [5]: a * 4
Out[5]: 'abcabcabcabc'
In [8]: '@' * 10
Out[8]: '@@@@@@@@@@'
  • in 或 not in：判断元素是否存在序列中
1
2
3
4
5
6
7
8
9
10
11
In [9]: 'a' in a
Out[9]: True
In [10]: a
Out[10]: 'abc'
In [11]: 'd' in a
Out[11]: False
In [12]: 'd' not in a
Out[12]: True
  • max()：返回最大值
1
2
In [13]: max(a)
Out[13]: 'c'
  • min()：返回最小值
1
2
In [14]: min(a)
Out[14]: 'a'
  • cmp(x,y)：比较两个个序列是否相等
1
2
3
4
5
6
7
8
9
10
11
12
13
14
In [15]: a
Out[15]: 'abc'
In [16]: cmp(a,'abc')
Out[16]: 0
In [17]: cmp(a,'abcd')
Out[17]: -1
In [18]: cmp(a,'ab')
Out[18]: 1
In [19]: cmp(a+'g','abcdef')
Out[19]: 1

元组

        Python 的元组与列表十分相似，不同之处在于元组的元素不能修改。

        元组和字符串一样是不可变的

  • 元组可以存储一系列的值
  • 元组通常用在用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变

        元组使用小括号，列表使用方括号。

        元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
In [21]: tup1 = ('python','a',1997,2017);
In [22]: type(tup1)
Out[22]: tuple
In [23]: tup2 = (1,2,3,4,(5,))
In [24]: type(tup2)
Out[24]: tuple
In [25]: tup3 = "a","b","c","d";
In [26]: type(tup3)
Out[26]: tuple

        创建空元组

1
2
3
4
In [27]: tup1 = ();
In [28]: type(tup1)
Out[28]: tuple

        元组中只包含一个元素时，需要在元素后面添加逗号

1
2
3
4
In [29]: tup1 = (50,);
In [30]: type(tup1)
Out[30]: tuple

        元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

访问元组

        元组可以使用下标索引来访问元组中的值

1
2
3
4
5
6
7
#!/usr/bin/python
tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );
print "tup1[0]: ", tup1[0]
print "tup2[1:5]: ", tup2[1:5]

        输出结果

1
2
tup1[0]:  physics
tup2[1:5]:  (2, 3, 4, 5)

修改元组

        元组的元素值是不允许修改的，但可以对元组进行连接组合

1
2
3
4
5
6
7
8
9
10
11
12
#!/usr/bin/python
# -*- coding: UTF-8 -*-
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');
# 以下修改元组元素操作是非法的。
# tup1[0] = 100;
# 创建一个新的元组
tup3 = tup1 + tup2;
print tup3;

        输出结果

1
(12,34,56,'abc','xyz')

删除元组

        元组中的元素值是不允许删除的，但可以使用 del 语句来删除整个元组

1
2
3
4
5
6
7
8
#!/usr/bin/python
tup = ('physics', 'chemistry', 1997, 2000);
print tup;
del tup;
print "After deleting tup : "
print tup;

        以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

1
2
3
4
5
6
('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last):
  File "test.py", line 9, in <module>
    print tup;
NameError: name 'tup' is not defined

元组运算符

        与字符串一样，元组之间可以使用 + 号和 号进行元算。这就意味着它们可以组合和复制，运算后会生成一个新的元组。
python表达式|结果|描述
—|—|—
len((1,2,3))|3|计算元素个数
（1，2，3） + （4，5，6）|（1，2，3，4，5，6）|连接
(‘Hi!’) 4|(‘Hi!’,’Hi!’,’Hi!’,’Hi!’)|复制
3 in (1,2,3)|true|元素是否存在
for x in (1,2,3):print x,|1 2 3 |迭代

元组索引、截取

        因为元组也是一个序列，所以可以访问元组中的指定位置的元素，也可以截取索引中的一段元素

1
L = ('spam','Spam','SPAM!')
python表达式 结果 描述
L[2] ‘SPANM!’ 读取第三个元素
L[-2] ‘Spam’ 反向读取；读取倒数第二个元素
L[1:] (‘Spam’,’SPAM!’) 截取元素

无关闭分隔符

        任意无符号的对象，以逗号隔开，默认为元组

1
2
3
4
5
#!/usr/bin/python
print 'abc', -4.24e93, 18+6.6j, 'xyz';
x, y = 1, 2;
print "Value of x , y : ", x,y;

        以上实例运行结果：

1
2
abc -4.24e+93 (18+6.6j) xyz
Value of x , y : 1 2

元组内置函数

        python元组包含了以下内置函数

序号 方法及描述
1 cmp(tuple1, tuple2)，比较两个元组元素。
2 len(tuple)，计算元组元素个数。
3 max(tuple)，返回元组中元素最大值。
4 min(tuple)，返回元组中元素最小值。
5 tuple(seq)，将列表转换为元组。

元组的拆分

        可以通过变量去接收元组的值,通常叫做元组的拆分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
In [31]: tup1 = (a,'b','c')
In [32]: tup1
Out[32]: ('abc', 'b', 'c')
In [33]: first,second,third = tup1
In [34]: first
Out[34]: 'abc'
In [35]: second
Out[35]: 'b'
In [36]: third
Out[36]: 'c'